package com.wangxs.cry.dec.utils;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONObject;

import javax.validation.*;
import java.lang.annotation.Annotation;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

/**
 * 参数验证工具类
 */
public class ValidateParamsUtil {

    /**
     * 实体类校验方法
     * @param params    参数
     * @param dataParamsClass   数据类型
     * @param isValidate    是否加密（false 否）
     * @param groups    分组（数组，可多选）
     * @param <T>   实体类对象
     * @return
     */
    public static <T> T validate(String params,
                                 Class<T> dataParamsClass,
                                 Boolean isValidate,
                                 Class<? extends Annotation>... groups) {
        T entity = JSONObject.parseObject(params, dataParamsClass);
        if (isValidate && CollectionUtil.isNotEmpty(Arrays.asList(groups))) {
            validateParams(entity, groups);
        }
        return entity;
    }

    /**
     * 实体类校验方法
     * @param params    参数
     * @param dataParamsClass   数据类型
     * @param groups    分组
     * @param <T>   实体类对象
     * @return
     */
    public static <T> T validate(String params,
                                 Class<T> dataParamsClass,
                                 Class<? extends Annotation>... groups) {
        return validate(params, dataParamsClass, true, groups);
    }

    /**
     * 集合转换校验方法
     * @param params    参数
     * @param dataParamsClass   数据类型
     * @param isValidate    是否加密（false 否）
     * @param groups    分组
     * @param <T>   实体类对象
     * @return
     */
    public static <T> List<T> validateList(String params,
                                 Class<T> dataParamsClass,
                                 Boolean isValidate,
                                 Class<? extends Annotation>... groups) {
        List<T> list = JSONObject.parseArray(params, dataParamsClass);
        if (CollectionUtil.isNotEmpty(list) && isValidate) {
            list.stream().forEach(v -> validateParams(v, groups));
        }
        return list;
    }

    /**
     * 集合转换校验方法
     * @param params    参数
     * @param dataParamsClass   数据类型
     * @param groups    分组
     * @param <T>   实体类对象
     * @return
     */
    public static <T> List<T> validateList(String params,
                                 Class<T> dataParamsClass,
                                 Class<? extends Annotation>... groups) {
        return validateList(params, dataParamsClass, true, groups);
    }

    /**
     * 校验实体类内部的注解中分组的参数
     * @param entity 实体类
     * @param groups 分组
     * @param <T> 实体类对象
     */
    private static <T> void validateParams(T entity, Class<? extends Annotation>[] groups) {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        Validator validator = factory.getValidator();
        Set<ConstraintViolation<T>> validate = validator.validate(entity, groups);
        if (!validate.isEmpty()) {
            for (ConstraintViolation<T> violation :
                    validate) {
                String message = violation.getMessage();
                throw new ValidationException(message);
            }
        }
    }
}
